home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d26 / inf_src.arc / VERIFY.C < prev    next >
C/C++ Source or Header  |  1986-03-14  |  6KB  |  243 lines
  1.  
  2. /*****************************************************************
  3. **                                **
  4. **      Inference -- (C) Copyright 1985 George Hageman    **
  5. **                                **
  6. **        user-supported software:                **
  7. **                                **
  8. **            George Hageman                **
  9. **            P.O. Box 11234                **
  10. **            Boulder, Colorado 80302            **
  11. **                                **
  12. *****************************************************************/
  13.  
  14. /********************************************************
  15. **
  16. **    verify(consequent)
  17. **
  18. **    finds the truth about the consequent -- returns
  19. **    TRUE if consequent is proved (all antecedents are TRUE)
  20. **    FALSE if any of the antecedents are FALSE
  21. **
  22. ********************************************************/
  23.  
  24. #include <stdio.h>
  25. #include "expert.h"
  26. #include "inference.h"
  27.  
  28. int    verify(cnsquent) 
  29.     int    cnsquent ;
  30.  
  31. {
  32. int     i,j,k,m,n ;
  33. int    antecedent[MAX_ANTECEDENTS] ;
  34. int    consequent[MAX_ANTECEDENTS] ;
  35. int    p_value ;            /* predicate value */
  36.  
  37. #ifdef DEBUG
  38.     int di ;
  39.     for(di=0;di<numTrue;di++)
  40.         printf("\nDEBUG-verify knownTrueFact = %d",knownTrue[di]) ;
  41.     for(di=0;di<numFalse;di++)
  42.         printf("\nDEBUG-verify knownFalseFact = %d",knownFalse[di]) ;
  43.  
  44. #endif
  45.  
  46. /*
  47. **
  48. **    get all of the antecedents for the consequent
  49. **
  50. **    First locate the antecedents -- should be directly in front
  51. **    of the consequent, delimited by a consequent with a flag of zero
  52. */
  53.  
  54. #ifdef DEBUG
  55.     printf("\nDEBUG -- verify consequent = %d",cnsquent ) ;
  56. #endif
  57.  
  58. j = 0 ;
  59.  
  60. for(i=cnsquent; i>=0 ; i--)
  61.     {
  62.     if(ruleBuff[i].flag == 0 )
  63.         break ;
  64.     }
  65.  
  66. if(i == -1)
  67.     {
  68.     printf("\n Bad Consequent, has no antecedents! returning TRUE value \n ") ;
  69.     return(TRUE);
  70.     }
  71.  
  72. for(i = i-1 ;i>=0; i--)
  73.     {
  74.     if(ruleBuff[i].flag != 0)
  75.         antecedent[j++]=i ;
  76.     else
  77.         break ;
  78.     }
  79.  
  80. if(j==0)
  81.     {
  82.     printf("\n Bad Consequent, has no antecedents! returning TRUE value \n ") ;
  83.     return(TRUE);
  84.     }
  85.     
  86. #ifdef DEBUG
  87.     printf("\nDEBUG -- verify antecedents = ") ;
  88.     for(di=0; di < j; di++)
  89.         printf("\n     %d -- %d",di,antecedent[di]) ;
  90. #endif
  91.  
  92. /*
  93. **    at this point we should have some antecedents in the antecedent
  94. **    stack so now lets see if each can be proved, and if there are
  95. **    any consequents which will need verification.
  96. */
  97.  
  98. /*
  99. **    main verificaiton loop:
  100. */
  101.  
  102. for(i=j-1 ; i >= 0 ; i--) /* for all of the antecedents in our stack */ 
  103.     {
  104.  
  105. /*
  106. **    determine if the antecedent is itself a consequent
  107. **    
  108. **    compare value of the string pointer of the antecedent needs to
  109. **    be compaired with the value of the string pointer of all of the
  110. **    consequents, if there is a match then the antecedent is a consequent
  111. **
  112. **    There may be more
  113. **    than one consequent and this is handled below since all of these
  114. **    must be false before we give up hope that one will be verified--
  115. **    REMEMBER -- consequents are not remembered FALSE they can only be
  116. **    remembered when they are true -- FALSEness for a consequent merely
  117. **    means that this particular rule did not verify it , some other one
  118. **    might.
  119. **
  120. */
  121.  
  122.     for(k=0; k< numHypot; k++ )
  123.         if(ruleBuff[hypStack[k]].string == ruleBuff[antecedent[i]].string)
  124.             break ;
  125.  
  126.     if(k != numHypot)  /* we have an antecedent which is a consequent */
  127.         {
  128.  
  129. #ifdef DEBUG
  130.     printf("\nDEBUG -- verify antecedent %d is consequent %d",i, antecedent[i] ) ;
  131. #endif
  132.  
  133. /*
  134. **    What we have is an antecedent which is a consequent of another
  135. **    rule or rules.  What is needed then is to place each of these consequents
  136. **    into a stack and prove them one at a time.  We will return truth
  137. **    if any of these are proven true and return false only when all of
  138. **    them are false.   We can use veriry recursively in this case to
  139. **    verify each one.
  140. **
  141. **    get all consequents matching hypStack[k].string into a stack
  142. **    look for truth of any consequent.
  143. **    if consequent is true (according to flag) return true.
  144. **    if all consequents are false then return false.
  145. */
  146.         n = 0 ;
  147.         for( m = 0 ; m < numHypot ; m++)
  148.             {
  149.             if(ruleBuff[antecedent[i]].string == ruleBuff[hypStack[m]].string)
  150.                 {
  151. #ifdef DEBUG
  152.                 printf("\nDEBUG--consequent stack(%d) = %d",n,hypStack[m]) ;
  153. #endif
  154.                 consequent[n++] = hypStack[m] ;
  155.                 }
  156.             }
  157. /*
  158. **    verify each consequent
  159. */
  160.  
  161.         p_value = FALSE ;
  162.         for(m = 0 ; m < n ; m++)        
  163.             {
  164.  
  165. #ifdef DEBUG
  166.     printf("\nDEBUG -- verify(2) consequent = %d",consequent[m] ) ;
  167. #endif
  168.             if( verify(consequent[m]) == TRUE )
  169.                 {
  170.                 p_value = TRUE ;
  171.                 if(known(consequent[m],knownTrue,numTrue) == FALSE)
  172.                     {
  173.                     printf("\nI infer that : %s\n",&strBuff[ruleBuff[consequent[m]].string]) ;
  174.                     knownTrue[numTrue++]=ruleBuff[consequent[m]].string ;
  175.                     }
  176.                 if(remAnte(antecedent[i]) == TRUE)
  177.                     {
  178.                     break ;
  179.                     }
  180.                 else
  181.                     {
  182.                     return(FALSE) ;
  183.                     }
  184.                 }
  185.             }
  186.         if(p_value == FALSE) /* all of the consequents were not proved */
  187.             {
  188.             switch(ruleBuff[antecedent[i]].flag)
  189.                 {
  190.                 case STRING_FALSE :
  191.                 case ROUTINE_FALSE :
  192.                     continue ;
  193.                 case STRING_TRUE :
  194.                 case STRING_TRUE_HYP :
  195.                 case ROUTINE_TRUE :
  196.                 case ROUTINE_TRUE_HYP :
  197.                     return(FALSE) ;
  198.                 }
  199.             }
  200.         else            /* at least one was known */
  201.             {
  202.             switch(ruleBuff[antecedent[i]].flag)
  203.                 {
  204.                 case STRING_TRUE :
  205.                 case STRING_TRUE_HYP :
  206.                 case ROUTINE_TRUE:
  207.                 case ROUTINE_TRUE_HYP:
  208.                     continue ;
  209.                 case STRING_FALSE :
  210.                 case ROUTINE_FALSE :
  211.                     return(FALSE) ;
  212.                 }
  213.             }
  214.         }
  215.         
  216.     else    /* we have a plane old string or routine antecedent */
  217.         
  218.         {
  219.         
  220.         if(weKnow(antecedent[i],&p_value) == TRUE)
  221.             {
  222.             if(p_value == TRUE)
  223.                 continue ;
  224.             else
  225.                 return(FALSE) ;
  226.             }
  227. /*
  228. **    Things arent known and are simple consequents so prove them
  229. **    either by asking the user or by running the routine
  230. */
  231.         if(verifyTruth(antecedent[i]) == TRUE)
  232.             continue ;
  233.         else
  234.             return(FALSE) ;
  235.         }
  236.     }
  237. /*
  238. **    Everything was TRUE in the big and statement so return it
  239. */
  240. return(TRUE) ;
  241. }
  242.  
  243.